//
//  DR_NativeAdManager.swift
//  DocReaderRP
//
//  Created by  mac on 2025/11/19.
//

import Foundation
import GoogleMobileAds

// MARK: - 原生广告管理器
class DR_NativeAdManager: NSObject {
    
    static let shared = DR_NativeAdManager()
    
    // 缓存的广告数组
    private var cachedAds: [NativeAd] = []
    
    // 当前请求的广告ID索引
    private var currentAdIndex: Int = 0
    
    // 广告配置
    private var adConfig: DR_AdTypeConfig?
    
    // 广告ID列表（按优先级排序）
    private var sortedAdIDs: [DR_AdID] = []
    
    // 场景配置列表
    private var sceneConfigs: [DR_AdSceneConfig] = []
    
    // 用户模型（1: 买量用户, 2: 普通用户）
    private var userModel: Int = 2
    
    // 当前正在请求的广告ID
    private var currentRequestingAdID: String?
    
    // 当前正在请求的 adLoader（需要保持引用）
    private var currentAdLoader: AdLoader?
    
    // 需要加载的广告数量
    private var remainingLoadCount: Int = 0
    
    // 请求完成的回调
    var onAdsLoaded: (([NativeAd]) -> Void)?
    var onAdsLoadFailed: ((Error?) -> Void)?
    
    private override init() {
        super.init()
    }
    
    // MARK: - 加载配置
    func loadConfig() {
        // 从 DR_RemoteManager 获取配置
        DR_RemoteManager.shared.fetchRemoteConfig { [weak self] result in
            guard let self = self else { return }
            
            switch result {
            case .success(let configModel):
                print("✅ [DR_NativeAdManager] 配置加载成功，开始解析")
                self.parseConfigModel(configModel)
            case .failure(let error):
                print("❌ [DR_NativeAdManager] 配置加载失败: \(error.localizedDescription)，使用本地配置")
                // 如果获取失败，使用本地配置
                self.parseConfig(adConfig_dic)
            }
        }
    }
    
    // MARK: - 解析配置模型
    private func parseConfigModel(_ configModel: DR_AdConfigModel) {
        // 设置用户模型
        self.userModel = configModel.userModelInt
        print("✅ [DR_NativeAdManager] 用户模型: \(userModel == 1 ? "买量用户" : "普通用户")")
        
        // 设置场景配置
        self.sceneConfigs = configModel.adSceneConfig
        print("✅ [DR_NativeAdManager] 场景配置加载成功，数量: \(sceneConfigs.count)")
        
        // 查找 native 类型的配置
        if let nativeConfig = configModel.adTypeConfig.first(where: { $0.type == "native" }) {
            self.adConfig = nativeConfig
            
            // 按优先级排序（从高到低）
            self.sortedAdIDs = nativeConfig.ids.sorted { $0.priority > $1.priority }
            
            print("✅ [DR_NativeAdManager] 配置加载成功，缓存数量: \(nativeConfig.cached), 广告ID数量: \(sortedAdIDs.count)")
            
            // 开始请求广告
            startLoadingAds()
        } else {
            print("❌ [DR_NativeAdManager] 未找到 native 类型配置")
        }
    }
    
    // MARK: - 解析配置
    private func parseConfig(_ configString: String) {
        guard let data = configString.data(using: .utf8) else {
            print("❌ [DR_NativeAdManager] 配置字符串转换失败")
            return
        }
        
        do {
            let json = try JSONSerialization.jsonObject(with: data, options: []) as? [String: Any]
            
            // 解析用户模型
            if let usermodelString = json?["usermodel"] as? String,
               let usermodel = Int(usermodelString) {
                self.userModel = usermodel
                print("✅ [DR_NativeAdManager] 用户模型: \(usermodel == 1 ? "买量用户" : "普通用户")")
            } else if let usermodel = json?["usermodel"] as? Int {
                self.userModel = usermodel
                print("✅ [DR_NativeAdManager] 用户模型: \(usermodel == 1 ? "买量用户" : "普通用户")")
            }
            
            // 解析场景配置
            if let adSceneConfigs = json?["adSceneConfig"] as? [[String: Any]] {
                let sceneConfigData = try JSONSerialization.data(withJSONObject: adSceneConfigs, options: [])
                self.sceneConfigs = try JSONDecoder().decode([DR_AdSceneConfig].self, from: sceneConfigData)
                print("✅ [DR_NativeAdManager] 场景配置加载成功，数量: \(self.sceneConfigs.count)")
            }
            
            // 解析广告类型配置
            guard let adTypeConfigs = json?["adTypeConfig"] as? [[String: Any]] else {
                print("❌ [DR_NativeAdManager] 无法找到 adTypeConfig")
                return
            }
            
            // 查找 native 类型的配置
            for configDict in adTypeConfigs {
                if let type = configDict["type"] as? String, type == "native" {
                    let configData = try JSONSerialization.data(withJSONObject: configDict, options: [])
                    self.adConfig = try JSONDecoder().decode(DR_AdTypeConfig.self, from: configData)
                    
                    // 按优先级排序（从高到低）
                    self.sortedAdIDs = self.adConfig?.ids.sorted { $0.priority > $1.priority } ?? []
                    
                    print("✅ [DR_NativeAdManager] 配置加载成功，缓存数量: \(self.adConfig?.cached ?? 0), 广告ID数量: \(self.sortedAdIDs.count)")
                    
                    // 开始请求广告
                    startLoadingAds()
                    return
                }
            }
            
            print("❌ [DR_NativeAdManager] 未找到 native 类型配置")
        } catch {
            print("❌ [DR_NativeAdManager] 配置解析失败: \(error.localizedDescription)")
        }
    }
    
    // MARK: - 开始加载广告
    func startLoadingAds() {
        guard let config = adConfig else {
            print("❌ [DR_NativeAdManager] 配置未加载")
            return
        }
        
        let targetCacheCount = config.cached
        let currentCacheCount = cachedAds.count
        
        // 如果缓存数量已达到目标，不需要再请求
        if currentCacheCount >= targetCacheCount {
            print("✅ [DR_NativeAdManager] 缓存已满，当前缓存: \(currentCacheCount), 目标: \(targetCacheCount)")
            onAdsLoaded?(cachedAds)
            return
        }
        
        // 需要请求的广告数量
        let needLoadCount = targetCacheCount - currentCacheCount
        
        print("📢 [DR_NativeAdManager] 开始加载广告，需要: \(needLoadCount), 当前缓存: \(currentCacheCount)")
        
        // 重置当前广告索引
        currentAdIndex = 0
        
        // 开始请求第一个广告
        loadNextAd(remainingCount: needLoadCount)
    }
    
    // MARK: - 加载下一个广告
    private func loadNextAd(remainingCount: Int) {
        self.remainingLoadCount = remainingCount
        
        guard remainingCount > 0 else {
            // 所有广告都已加载完成
            print("✅ [DR_NativeAdManager] 所有广告加载完成，当前缓存: \(cachedAds.count)")
            onAdsLoaded?(cachedAds)
            return
        }
        
        // 如果所有广告ID都尝试过了，重新开始
        if currentAdIndex >= sortedAdIDs.count {
            print("⚠️ [DR_NativeAdManager] 所有广告ID都已尝试，重新开始")
            currentAdIndex = 0
        }
        
        guard currentAdIndex < sortedAdIDs.count else {
            print("❌ [DR_NativeAdManager] 没有可用的广告ID")
            onAdsLoadFailed?(NSError(domain: "DR_NativeAdManager", code: -1, userInfo: [NSLocalizedDescriptionKey: "没有可用的广告ID"]))
            return
        }
        
        let adID = sortedAdIDs[currentAdIndex]
        currentRequestingAdID = adID.id
        
        print("📢 [DR_NativeAdManager] 开始请求广告 ID: \(adID.id), Priority: \(adID.priority), 剩余: \(remainingCount)")
        
        // 创建广告请求
        let adLoader = AdLoader(adUnitID: adID.id, rootViewController: nil, adTypes: [.native], options: nil)
        adLoader.delegate = self
        
        // 保存引用，避免被释放
        self.currentAdLoader = adLoader
        
        let request = Request()
        adLoader.load(request)
    }
    
    // MARK: - 获取缓存的广告
    func getCachedAd() -> NativeAd? {
        guard !cachedAds.isEmpty else {
            return nil
        }
        
        // 返回第一个缓存的广告
        return cachedAds.first
    }
    
    // MARK: - 根据场景获取广告
    /// 根据场景判断是否展示广告，如果展示则返回缓存的 NativeAd
    /// - Parameter scene: 场景名称（如 "launch", "home_native", "list_native" 等）
    /// - Returns: 如果应该展示广告，返回 NativeAd；否则返回 nil
    func getNativeAd(for scene: String) -> NativeAd? {
        // 查找场景配置
        guard let sceneConfig = sceneConfigs.first(where: { $0.scene == scene }) else {
            print("⚠️ [DR_NativeAdManager] 未找到场景配置: \(scene)")
            return nil
        }
        
        // 根据 sceneModel 和 userModel 判断是否展示
        let shouldShow = shouldShowAd(sceneModel: sceneConfig.sceneModel, userModel: userModel)
        
        if !shouldShow {
            print("ℹ️ [DR_NativeAdManager] 场景 '\(scene)' 不展示广告 (sceneModel: \(sceneConfig.sceneModel), userModel: \(userModel))")
            return nil
        }
        
        // 如果应该展示，返回缓存的广告
        if let ad = getCachedAd() {
            print("✅ [DR_NativeAdManager] 场景 '\(scene)' 展示广告")
            return ad
        } else {
            print("⚠️ [DR_NativeAdManager] 场景 '\(scene)' 需要展示广告，但缓存为空，开始加载")
            // 如果缓存为空，尝试加载广告
            startLoadingAds()
            return nil
        }
    }
    
    // MARK: - 判断是否应该展示广告
    /// 根据 sceneModel 和 userModel 判断是否应该展示广告
    /// - Parameters:
    ///   - sceneModel: 场景模式（1: 都展示, 0: 仅买量用户展示, -1: 都不展示）
    ///   - userModel: 用户模型（1: 买量用户, 2: 普通用户）
    /// - Returns: 是否应该展示广告
    private func shouldShowAd(sceneModel: Int, userModel: Int) -> Bool {
        switch sceneModel {
        case 1:
            // 买量用户和普通用户都展示
            return true
        case 0:
            // 买量用户展示、普通用户不展示
            return userModel == 1
        case -1:
            // 买量用户和普通用户都不展示
            return false
        default:
            // 未知的 sceneModel，默认不展示
            print("⚠️ [DR_NativeAdManager] 未知的 sceneModel: \(sceneModel)")
            return false
        }
    }
    
    // MARK: - 移除已使用的广告
    func removeAd(_ ad: NativeAd) {
        if let index = cachedAds.firstIndex(where: { $0 === ad }) {
            cachedAds.remove(at: index)
            print("📢 [DR_NativeAdManager] 移除已使用的广告，剩余缓存: \(cachedAds.count)")
            
            // 如果缓存不足，重新加载
            if let config = adConfig, cachedAds.count < config.cached {
                startLoadingAds()
            }
        }
    }
    
    // MARK: - 清空缓存
    func clearCache() {
        cachedAds.removeAll()
        currentAdIndex = 0
        currentRequestingAdID = nil
        currentAdLoader = nil
        remainingLoadCount = 0
        print("📢 [DR_NativeAdManager] 缓存已清空")
    }
}

// MARK: - GADNativeAdLoaderDelegate
extension DR_NativeAdManager: NativeAdLoaderDelegate {
    
    func adLoader(_ adLoader: AdLoader, didReceive nativeAd: NativeAd) {
        print("✅ [DR_NativeAdManager] 广告加载成功: \(adLoader.adUnitID)")
        
        // 添加到缓存
        cachedAds.append(nativeAd)
        
        // 重置当前广告索引，下次从最高优先级开始（因为成功加载了，优先使用高优先级）
        currentAdIndex = 0
        currentAdLoader = nil
        
        // 检查是否还需要加载更多广告
        if let config = adConfig {
            let remainingCount = config.cached - cachedAds.count
            if remainingCount > 0 {
                // 继续加载下一个广告（从最高优先级开始）
                loadNextAd(remainingCount: remainingCount)
            } else {
                // 缓存已满
                print("✅ [DR_NativeAdManager] 缓存已满，当前缓存: \(cachedAds.count)")
                onAdsLoaded?(cachedAds)
            }
        }
    }
    
    func adLoader(_ adLoader: AdLoader, didFailToReceiveAdWithError error: Error) {
        print("❌ [DR_NativeAdManager] 广告加载失败: \(adLoader.adUnitID), Error: \(error.localizedDescription)")
        
        // 清除当前 adLoader 引用
        currentAdLoader = nil
        
        // 当前广告ID请求失败，尝试下一个优先级的广告ID
        currentAdIndex += 1
        
        // 检查是否还有可用的广告ID
        if currentAdIndex < sortedAdIDs.count {
            // 尝试下一个优先级的广告ID
            if let config = adConfig {
                let remainingCount = config.cached - cachedAds.count
                if remainingCount > 0 {
                    loadNextAd(remainingCount: remainingCount)
                } else {
                    // 缓存已满，但当前请求失败
                    if !cachedAds.isEmpty {
                        print("⚠️ [DR_NativeAdManager] 当前请求失败，但缓存已满: \(cachedAds.count)")
                        onAdsLoaded?(cachedAds)
                    }
                }
            }
        } else {
            // 所有广告ID都尝试过了
            if let config = adConfig {
                let remainingCount = config.cached - cachedAds.count
                if remainingCount > 0 {
                    // 重新开始请求（从最高优先级开始）
                    print("⚠️ [DR_NativeAdManager] 所有广告ID都失败，重新开始请求")
                    currentAdIndex = 0
                    loadNextAd(remainingCount: remainingCount)
                } else {
                    // 至少有一些广告已缓存
                    if !cachedAds.isEmpty {
                        print("⚠️ [DR_NativeAdManager] 部分广告加载失败，但已有缓存: \(cachedAds.count)")
                        onAdsLoaded?(cachedAds)
                    } else {
                        // 完全没有广告，重新开始请求
                        print("❌ [DR_NativeAdManager] 所有广告加载失败，重新开始请求")
                        currentAdIndex = 0
                        loadNextAd(remainingCount: config.cached)
                    }
                }
            }
        }
    }
}

// MARK: - GADAdLoaderDelegate
extension DR_NativeAdManager: AdLoaderDelegate {
    func adLoaderDidFinishLoading(_ adLoader: AdLoader) {
        // 广告加载器完成加载（所有广告都已加载或失败）
        print("📢 [DR_NativeAdManager] 广告加载器完成加载")
    }
}
